// 错题查看页面
const app = getApp();

Page({
  data: {
    list: [1, 2, 3, 3, 3, 3, 3],
    totalHeaderHeightall: "",
    showPinglunModal: false, // 控制评论弹窗显示
    currentQuestion: null, // 当前题目详情
    questionId: '', // 题目ID
    isAnswered: true, // 默认为已作答状态，直接显示答案
    isCorrect: false, // 不需要判断正确性
    userAnswer: null, // 不需要用户答案
    questionIndex: 0, // 当前题目索引
    subjectId: '', // 科目ID
    chapterId: '', // 章节ID
    chapterName: '', // 章节名称
    subjectName: '', // 科目名称
    questionType: '单选题', // 题目类型，默认为单选题
    isInErrorBook: true // 是否在错题本中
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    // 获取页面参数
    this.setData({
      totalHeaderHeightall: app.globalData?.totalHeaderHeight,
      questionId: options.id || options.questionId || 0, // 同时支持id和questionId参数
      questionIndex: parseInt(options.questionIndex) || 0, // 当前题目索引
      subjectId: options.subjectId || '', // 科目ID
      chapterId: options.chapterId || '', // 章节ID
      chapterName: decodeURIComponent(options.chapterName || ''),
      subjectName: decodeURIComponent(options.subjectName || ''),
      isInErrorBook: true // 标记为错题本模式
    });

    console.log('错题本查看页面加载参数:', options);

    // 加载题目详情
    if (this.data.questionId > 0) {
      this.loadQuestionDetail();
    }
  },

  onReady: function () {
    // 获取自定义头部高度
    const query = wx.createSelectorQuery();
    query.select('#customHeader').boundingClientRect();
    query.exec((res) => {
      if (res && res[0]) {
        const headerHeight = res[0].height;
        this.setData({
          totalHeaderHeightall: headerHeight
        });
      }
    });
  },


  onBannerTap: function (e) {
    const { index } = e.currentTarget.dataset;
    const banner = this.data.banners[index];

    // 如果有跳转链接则跳转，否则执行原广告点击逻辑
    if (banner.url) {
      // this.setData({
      //   massges: "暂未开放活动",
      //   showmsg: true
      // })
      // setTimeout(() => {
      //   this.setData({
      //     showmsg: false
      //   })
      // }, 1000);
      wx.navigateTo({
        url: banner.url
      });
    } else {
      this.onGuanggaoTap();
    }
  },

  /**
   * 加载题目详情
   */
  loadQuestionDetail: async function () {
    try {
      console.log('开始加载题目详情，题目ID:', this.data.questionId);
      // 调用获取题目详情API，直接传递questionId
      const res = await app.api.getQuestionDetail(this.data.questionId);

      console.log('API返回结果:', res);

      if (res.code === 200 && res.data) {
        // 更新题目类型
        let questionType = '单选题';
        if (res.data.type === 'multiple') questionType = '多选题';
        else if (res.data.type === 'judge') questionType = '判断题';

        // 处理可能包含JSON字符串的字段
        let processedData = res.data;

        // 处理options字段
        if (processedData.options && typeof processedData.options === 'string') {
          try {
            // 尝试解析为JSON对象
            const parsedOptions = JSON.parse(processedData.options);
            // 检查解析后的结果是否为数组
            if (Array.isArray(parsedOptions)) {
              processedData.options = parsedOptions;
            } else {
              // 如果不是数组，使用默认选项
              processedData.options = [
                { key: 'A', content: '选项A' },
                { key: 'B', content: '选项B' },
                { key: 'C', content: '选项C' },
                { key: 'D', content: '选项D' }
              ];
            }
          } catch (e) {
            console.error('解析options失败:', e);
            // 如果解析失败，使用默认选项
            processedData.options = [
              { key: 'A', content: '选项A' },
              { key: 'B', content: '选项B' },
              { key: 'C', content: '选项C' },
              { key: 'D', content: '选项D' }
            ];
          }
        }

        // 重点处理content字段，因为这可能是JSON显示问题的源头
        if (processedData.content && typeof processedData.content === 'string') {
          // 检查content是否看起来像包含options的JSON对象
          if (processedData.content.includes('"options"') &&
            processedData.content.includes('"content"') &&
            processedData.content.includes('"key"')) {
            try {
              console.log('检测到content可能包含题目JSON对象，尝试解析...');
              const parsedContent = JSON.parse(processedData.content);
              if (parsedContent && typeof parsedContent === 'object') {
                // 如果解析成功且包含options，将其提取并更新到processedData
                if (parsedContent.options) {
                  console.log('成功从content中提取options字段');
                  processedData.options = parsedContent.options;
                  // 替换content，并设置question_name
                  processedData.content = '题目详情';
                  // 如果没有question_name，设置一个默认值
                  if (!processedData.question_name) {
                    processedData.question_name = '题目详情';
                  }
                }
              }
            } catch (e) {
              console.error('解析content中的JSON失败:', e);
            }
          }
        }

        // 确保question_name字段存在
        if (!processedData.question_name) {
          // 如果没有question_name，使用title或content作为后备
          processedData.question_name = processedData.title || processedData.content || '题目详情';
        }

        // 最后的安全检查，确保options是数组格式
        if (!Array.isArray(processedData.options)) {
          console.warn('options不是数组，使用默认选项');
          processedData.options = [
            { key: 'A', content: '选项A - 默认' },
            { key: 'B', content: '选项B - 默认' },
            { key: 'C', content: '选项C - 默认' },
            { key: 'D', content: '选项D - 默认' }
          ];
        }

        // 确保right_key字段存在，如果不存在但有answer字段，使用answer作为后备
        if (!processedData.right_key && processedData.answer) {
          processedData.right_key = processedData.answer;
        }

        console.log('处理后的数据:', processedData);

        this.setData({
          currentQuestion: processedData,
          questionType: questionType,
          isAnswered: true, // 直接设置为已作答状态，显示答案
          isCorrect: false, // 不需要判断正确性
          userAnswer: null // 不需要用户答案
        });
      } else {
        // 使用模拟数据
        this.setData({
          currentQuestion: {
            id: this.data.questionId,
            question_name: '模拟题目：选择正确的尺寸范围', // 添加question_name字段
            title: '这是一道模拟错题，用于测试答题页面功能。',
            content: '请选择正确的选项进行作答。',
            right_key: 'B', // 使用right_key作为正确答案字段
            answer: 'B', // 保留answer字段以保持兼容性
            options: [
              { key: 'A', content: '选项A - 错误选项' },
              { key: 'B', content: '选项B - 正确选项' },
              { key: 'C', content: '选项C - 错误选项' },
              { key: 'D', content: '选项D' }
            ],
            analysis: '这是题目解析，用于帮助理解正确答案。'
          },
          isAnswered: true, // 直接设置为已作答状态
          isCorrect: false,
          userAnswer: null
        });
      }
    } catch (error) {
      console.error('加载题目详情失败:', error);

      // 加载失败时使用模拟数据
      this.setData({
        currentQuestion: {
          id: this.data.questionId,
          question_name: '加载失败的题目示例', // 添加question_name字段
          title: '加载题目失败，显示模拟数据',
          content: '无法加载题目详情，请检查网络连接后重试。',
          right_key: 'B', // 使用right_key作为正确答案字段
          answer: 'B', // 保留answer字段以保持兼容性
          options: [
            { key: 'A', content: '选项A - 示例选项' },
            { key: 'B', content: '选项B - 正确示例' },
            { key: 'C', content: '选项C - 示例选项' },
            { key: 'D', content: '选项D - 示例选项' }
          ],
          analysis: '题目加载失败，请重试。'
        },
        isAnswered: true, // 直接设置为已作答状态
        isCorrect: false,
        userAnswer: null
      });
    }
  },



  /**
   * 打开评论弹窗
   */
  openPinglunModal: function () {
    this.setData({ showPinglunModal: true });
  },

  /**
   * 关闭评论弹窗
   */
  closePinglunModal: function () {
    this.setData({ showPinglunModal: false });
  },

  /**
   * 处理评论提交
   */
  handlePinglunSubmit: function (e) {
    const { content, commentId } = e.detail;
    console.log('收到评论内容:', content, '评论ID:', commentId);

    // 评论组件已经调用了API，这里只需要关闭弹窗
    this.closePinglunModal();
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function () {
    return {
      title: '错题查看 - ' + this.data.chapterName,
      path: `/pages/errorbook/dati/dati?questionId=${this.data.questionId}&chapterId=${this.data.chapterId}&subjectId=${this.data.subjectId}&fromErrorBook=true`
    };
  }
});